In software engineering, Pull Up refactoring involves moving a member of a class, such as a method, from a Subclass into a Superclass.
This refactoring is especially useful when subclasses of a certain class share some functionality but each implements it separately. Moving the shared functionality (using Extract Method if need be, or just moving the method) to the superclass will keep the functionality of the subclasses as it is, and give us less code duplication and better code readability.Please note that this refactoring shouldn't be used if only relatively few subclasses share a functionality, since this will add (probably) unintended functionality to other (most of the other ) subclasses. Suppose we have a class A and it's subclasses B, C, D, E, F and G. If B and C share a method (for example), then a better solution in this case is creating a class that will have the B and C's shared method (let's call it Z), and have B and C use the method from that class (Z in this example). That process is called Extract Class. Another option would be making Z extend A and then making B and C extend Z.
Compare the following Java classes before and after the Pull Up refactoring is applied on myMethod2:
public class Superclass{
void myMethod(){
//do something
}
}
public class Subclass extends Superclass{
void myMethod() {
//do something
}
void myMethod2() {
//do something else
}
}
After the Pull Up refactoring is applied:
public class Superclass{
void myMethod(){
//do something
}
void myMethod2() {
//do something else
}
}
public class Subclass extends Superclass{
void myMethod() {
//do something
}
}